package com.snoob.springboot.wConfig.redis;

import com.snoob.springboot.util.StrUtil;
import org.redisson.api.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @描述: Redis官方推荐的Java版的Redis客户端，功能非常强大
 * @作者: lixing
 * @日期 2021/7/1 17:20
 */
@Service
public class RedissonSingleServiceImpl<E> implements RedissonSingleService<E> {
    /**
     * 基于单节点的redis客户端
     */
    @Resource
    private RedissonClient redissonSingleClient;

    /**
     * @return boolean
     * @描述 当前key是否存在
     * @作者 lixing
     * @日期 2021/7/4 13:58
     * @Param [key]
     */
    @Override
    public boolean isExists(String key) {
        return redissonSingleClient.getBucket(key).isExists();
    }

    /**
     * @描述 设置key指定毫秒后过期
     * @作者 lixing
     * @日期 2021/7/4 14:00
     * @Param [key, milliseconds 有效期]
     */
    @Override
    public void setExpire(String key, long milliseconds) {
        redissonSingleClient.getBucket(key).expire(milliseconds, TimeUnit.MILLISECONDS);
    }

    // TODO ============================================================================================== key值自增、自减
    /**
     * @描述 设置key的值自增value后并返回
     * @作者 lixing
     * @日期 2021/7/4 14:02
     * @Param [key value]
     */
    @Override
    public long setIncrementByAtomicLong(String key, long value) {
        return redissonSingleClient.getAtomicLong(key).addAndGet(value);
    }
    @Override
    public double setIncrementAtomicDouble(String key, double value) {
        return redissonSingleClient.getAtomicDouble(key).addAndGet(value);
    }

    /**
     * @描述 设置key的值自增
     * @作者 lixing
     * @日期 2021/7/4 14:02
     * @Param [key]
     */
    @Override
    public void setIncrementByLongAdder(String key) {
        redissonSingleClient.getLongAdder(key).increment();
    }
    @Override
    public void setIncrementByDoubleAdder(String key) {
        redissonSingleClient.getDoubleAdder(key).increment();
    }

    /**
     * @描述 设置key的值自减
     * @作者 lixing
     * @日期 2021/7/4 14:02
     * @Param [key]
     */
    @Override
    public void setDecrementByLongAdder(String key) {
        redissonSingleClient.getLongAdder(key).decrement();
    }

    @Override
    public void setDecrementByDoubleAdder(String key) {
        redissonSingleClient.getDoubleAdder(key).decrement();
    }

    // TODO ========================================================================================== 通用对象桶（Bucket）
    // TODO RBucket Java对象是一种通用对象桶可以用来存放任类型的对象
    /**
     * @描述 添加 key
     * @作者 lixing
     * @日期 2021/7/4 14:11
     * @Param [key, value]
     */
    @Override
    public void setKey(String key, E value) {
        redissonSingleClient.getBucket(key).set(value);
    }

    /**
     * @描述 添加 key
     * @作者 lixing
     * @日期 2021/7/4 14:11
     * @Param [key, value, milliseconds 有效期]
     */
    @Override
    public void setKey(String key, E value, long milliseconds) {
        redissonSingleClient.getBucket(key).set(value, milliseconds, TimeUnit.MILLISECONDS);
    }

    /**
     * @描述 尝试添加 key，如果key存在则失败
     * @作者 lixing
     * @日期 2021/7/4 14:11
     * @Param [key, value]
     */
    @Override
    public boolean trySetKey(String key, E value) {
        return redissonSingleClient.getBucket(key).trySet(value);
    }

    /**
     * @描述 尝试添加 key，如果key存在则失败
     * @作者 lixing
     * @日期 2021/7/4 14:11
     * @Param [key, value, milliseconds 超时时间]
     */
    @Override
    public boolean trySetKey(String key, E value, long milliseconds) {
        return redissonSingleClient.getBucket(key).trySet(value, milliseconds, TimeUnit.MILLISECONDS);
    }

    /**
     * @描述 通过 CAS 更新 key
     * @作者 lixing
     * @日期 2021/7/10 17:40
     * @Param [key, oldValue 更新前的值, newValue 更新后的值]
     * @return boolean
     */
    @Override
    public boolean compareAndSet(String key, E oldValue, E newValue) {
        return redissonSingleClient.getBucket(key).compareAndSet(oldValue, newValue);
    }

    /**
     * @描述 返回 key 的旧值并设置新值
     * @作者 lixing
     * @日期 2021/7/4 14:18
     * @Param [key, newValue 新值]
     * @return E
     */
    @Override
    public E getAndSet(String key, E newValue) {
        RBucket<E> rBucket = redissonSingleClient.getBucket(key);
        return rBucket.getAndSet(newValue);
    }

    /**
     * @描述 返回 key 的旧值并设置新值
     * @作者 lixing
     * @日期 2021/7/4 14:18
     * @Param [key, newValue 新值，milliseconds 超时时间]
     * @return E
     */
    @Override
    public E getAndSet(String key, E newValue, long milliseconds) {
        RBucket<E> rBucket = redissonSingleClient.getBucket(key);
        return rBucket.getAndSet(newValue, milliseconds, TimeUnit.MILLISECONDS);
    }

    /**
     * @描述 查询 key
     * @作者 lixing
     * @日期 2021/7/4 14:18
     * @Param [key]
     * @return E
     */
    @Override
    public E getKey(String key) {
        RBucket<E> rBucket = redissonSingleClient.getBucket(key);
        return rBucket.get();
    }

    /**
     * @描述 查询 keys
     * @作者 lixing
     * @日期 2021/7/10 17:48
     * @Param [key]
     * @return java.util.List<E>
     */
    @Override
    public Map<String, E> getKeys(String[] keys) {
        RBuckets buckets = redissonSingleClient.getBuckets();
        Map<String, E> loadedBuckets = buckets.get(keys);
        return loadedBuckets;
    }

    /**
     * @描述 查询 key 并删除
     * @作者 lixing
     * @日期 2021/7/4 14:18
     * @Param [key]
     * @return E
     */
    @Override
    public E getAndDelete(String key) {
        RBucket<E> rBucket = redissonSingleClient.getBucket(key);
        return rBucket.getAndDelete();
    }

    /**
     * @return boolean
     * @描述 删除key
     * @作者 lixing
     * @日期 2021/7/4 14:05
     * @Param [key]
     */
    @Override
    public boolean delKey(String key) {
        return redissonSingleClient.getBucket(key).delete();
    }

    // TODO ==================================================================================================== 二进制流
    /**
     * @描述 添加
     * @作者 lixing
     * @日期 2021/7/10 13:59
     * @Param [key, bytes]
     */
    @Override
    public void setBinaryStream(String key, byte[] bytes) {
        RBinaryStream stream = redissonSingleClient.getBinaryStream("key");
        stream.set(bytes);
    }

    /**
     * @描述 添加
     * @作者 lixing
     * @日期 2021/7/10 13:59
     * @Param [key, bytes, milliseconds 有效期]

     */
    @Override
    public void setBinaryStream(String key, byte[] bytes, long milliseconds) {
        RBinaryStream stream = redissonSingleClient.getBinaryStream("key");
        stream.set(bytes, milliseconds, TimeUnit.MILLISECONDS);
    }

    /**
     * @描述 查询
     * @作者 lixing
     * @日期 2021/7/10 14:00
     * @Param [key]
     * @return org.redisson.api.RBinaryStream
     */
    @Override
    public RBinaryStream getBinaryStream(String key) {
        RBinaryStream stream = redissonSingleClient.getBinaryStream("key");
        return stream;
    }

    // TODO ======================================================================================================== bit
    /**
     * @描述 添加 bit key
     * @作者 lixing
     * @日期 2021/7/4 14:11
     * @Param [key, index, flag]
     */
    @Override
    public void setBit(String key, long index, boolean flag) {
        RBitSet bit = redissonSingleClient.getBitSet(key);
        bit.set(index, flag);
    }

    /**

     * @描述 查询 bit key
     * @作者 lixing
     * @日期 2021/7/4 14:11
     * @Param [key, index]
     */
    @Override
    public boolean getBit(String key, long index) {
        RBitSet bit = redissonSingleClient.getBitSet(key);
        return bit.get(index);
    }

    /**
     * @描述 获取 bit 数量
     * @作者 lixing
     * @日期 2021/7/4 14:36
     * @Param [key]
     * @return long
     */
    @Override
    public long getBitSize(String key) {
        RBitSet bit = redissonSingleClient.getBitSet(key);
        return bit.size();
    }

    // TODO ================================================================================================ HyperLogLog
    /**
     * @描述 添加 HyperLogLog
     * @作者 lixing
     * @日期 2021/7/4 14:31
     * @Param [key, value]

     */
    @Override
    public boolean setHyperLogLog(String key, E value) {
        RHyperLogLog<E> hyperLogLog = redissonSingleClient.getHyperLogLog(key);
        return hyperLogLog.add(value);
    }

    /**
     * @描述 查询 HyperLogLog
     * @作者 lixing
     * @日期 2021/7/4 14:33
     * @Param [key]
     * @return long
     */
    @Override
    public long getHyperLogLog(String key) {
        RHyperLogLog<E> hyperLogLog = redissonSingleClient.getHyperLogLog(key);
        return hyperLogLog.count();
    }

    // TODO =================================================================================================== LIST 列表
    /**
     * @描述 添加 list key
     * @作者 lixing
     * @日期 2021/7/4 14:45
     * @Param [key, value]
     */
    @Override
    public void setList(String key, E value) {
        RList<E> rList = redissonSingleClient.getList(key);
        rList.add(value);
    }

    /**
     * @描述 查询 list key
     * @作者 lixing
     * @日期 2021/7/4 14:45
     * @Param [key]
     */
    @Override
    public List<E> getList(String key) {
        RList<E> rList = redissonSingleClient.getList(key);
        return rList.readAll();
    }

    /**
     * @描述 查询 list key
     * @作者 lixing
     * @日期 2021/7/4 14:45
     * @Param [key, index 索引]
     */
    @Override
    public E getList(String key, int index) {
        RList<E> rList = redissonSingleClient.getList(key);
        return rList.get(index);
    }

    /**
     * @描述 删除 list key
     * @作者 lixing
     * @日期 2021/7/10 17:59
     * @Param [key, value]
     */
    @Override
    public boolean removeList(String key, E value) {
        RList<E> rList = redissonSingleClient.getList(key);
        return rList.remove(value);
    }

    /**
     * @描述 删除 list key
     * @作者 lixing
     * @日期 2021/7/10 17:59
     * @Param [key, index 索引]
     */
    @Override
    public E removeList(String key, int index) {
        RList<E> rList = redissonSingleClient.getList(key);
        return rList.remove(index);
    }

    // TODO ================================================================================================== Queue 队列
    /**
     * @描述 添加 Queue key
     * @作者 lixing
     * @日期 2021/7/4 14:45
     * @Param [key]
     */
    @Override
    public boolean setQueue(String key, E value) {
        RQueue<E> rQueue = redissonSingleClient.getQueue(key);
        return rQueue.add(value);
    }

    /**
     * @描述 删除 Queue key 并返回
     * @作者 lixing
     * @日期 2021/7/4 15:06
     * @Param [key, value]
     * @return E
     */
    @Override
    public E getAndDelQueue(String key) {
        RQueue<E> rQueue = redissonSingleClient.getQueue(key);
        return rQueue.poll();
    }

    /**
     * @描述 查询 Queue key
     * @作者 lixing
     * @日期 2021/7/4 15:06
     * @Param [key, value]
     * @return E
     */
    @Override
    public E getQueue(String key) {
        RQueue<E> rQueue = redissonSingleClient.getQueue(key);
        return rQueue.peek();
    }

    // TODO ====================================================================================== BlockingQueue 阻塞队列
    /**
     * @描述 添加 BlockingQueue key
     * @作者 lixing
     * @日期 2021/7/4 15:06
     * @Param [key, value]
     */
    @Override
    public boolean setBlockingQueue(String key, E value) {
        RBlockingQueue<E> rBlockingQueue = redissonSingleClient.getBlockingQueue(key);
        return rBlockingQueue.add(value);
    }

    /**
     * @描述 删除 BlockingQueue key 并返回
     * @作者 lixing
     * @日期 2021/7/4 15:06
     * @Param [key, milliseconds 超时时间]
     * @return E
     */
    @Override
    public E getAndDelBlockingQueue(String key, long milliseconds) {
        RBlockingQueue<E> rBlockingQueue = redissonSingleClient.getBlockingQueue(key);
        try {
            return rBlockingQueue.poll(milliseconds, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @描述 查询 BlockingQueue key
     * @作者 lixing
     * @日期 2021/7/4 15:06
     * @Param [key, value]
     * @return E
     */
    @Override
    public E getBlockingQueue(String key) {
        RBlockingQueue<E> rBlockingQueue = redissonSingleClient.getBlockingQueue(key);
        return rBlockingQueue.peek();
    }

    // TODO ============================================================================================== Deque 双端队列
    /**
     * @描述 添加 deque(从第一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 14:54
     * @Param [key, value]

     */
    @Override
    public void setDequeByFirst(String key, E value) {
        RDeque<E> rDeque = redissonSingleClient.getDeque(key);
        rDeque.addFirst(value);
    }

    /**
     * @描述 添加 deque(从最后一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 14:54
     * @Param [key, value]

     */
    @Override
    public void setDequeByLast(String key, E value) {
        RDeque<E> rDeque = redissonSingleClient.getDeque(key);
        rDeque.addLast(value);
    }

    /**
     * @描述 获取 deque(从第一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 15:00
     * @Param [key]
     * @return E
     */
    @Override
    public E getDequeByFirst(String key) {
        RDeque<E> rDeque = redissonSingleClient.getDeque(key);
        return rDeque.pollFirst();
    }

    /**
     * @描述 获取 deque(从最后一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 15:00
     * @Param [key]
     * @return E
     */
    @Override
    public E getDequeByLast(String key) {
        RDeque<E> rDeque = redissonSingleClient.getDeque(key);
        return rDeque.pollLast();
    }

    // TODO =========================================================================================== Deque 阻塞双端队列
    /**
     * @描述 添加 deque(从第一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 14:54
     * @Param [key, value]
     */
    @Override
    public void setBlockingDequeByFirst(String key, E value) {
        RBlockingDeque<E> rBlockingDeque = redissonSingleClient.getBlockingDeque(key);
        rBlockingDeque.addFirst(value);
    }

    /**
     * @描述 添加 deque(从最后一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 14:54
     * @Param [key, value]
     */
    @Override
    public void setBlockingDequeByLast(String key, E value) {
        RBlockingDeque<E> rBlockingDeque = redissonSingleClient.getBlockingDeque(key);
        rBlockingDeque.addLast(value);
    }

    /**
     * @描述 获取 deque(从第一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 15:00
     * @Param [key，milliseconds 超时时间]
     */
    @Override
    public E getBlockingDequeByFirst(String key, long milliseconds) {
        RBlockingDeque<E> rBlockingDeque = redissonSingleClient.getBlockingDeque(key);
        try {
            return rBlockingDeque.pollFirst(1000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @描述 获取 deque(从最后一个元素开始添加) key
     * @作者 lixing
     * @日期 2021/7/4 15:00
     * @Param [key，milliseconds 超时时间]
     */
    @Override
    public E getBlockingDequeByLast(String key, long milliseconds) {
        RBlockingDeque<E> rBlockingDeque = redissonSingleClient.getBlockingDeque(key);
        try {
            return rBlockingDeque.pollLast(milliseconds, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
            return null;
        }
    }

    // TODO ==================================================================================================== SET 集合
    /**
     * @描述 添加 set key
     * @作者 lixing
     * @日期 2021/7/4 15:10
     * @Param [key, value]
     */
    @Override
    public void setSet(String key, E value) {
        RSet<E> rSet = redissonSingleClient.getSet(key);
        rSet.add(value);
    }

    /**
     * @描述 查询 set key
     * @作者 lixing
     * @日期 2021/7/4 15:13
     * @Param [key]
     * @return java.util.Set<E>
     */
    @Override
    public Set<E> getSet(String key) {
        RSet<E> rSet = redissonSingleClient.getSet(key);
        return rSet.readAll();
    }

    /**
     * @描述 随机 set key
     * @作者 lixing
     * @日期 2021/7/4 15:15
     * @Param [key, number 随机数量, isDel 是否删除]
     * @return java.util.Set<E>
     */
    @Override
    public Set<E> getSetByRandom(String key, int number, boolean isDel) {
        RSet<E> rSet = redissonSingleClient.getSet(key);
        if (isDel) {
            return rSet.removeRandom(number);
        }
        return rSet.random(number);
    }

    /**
     * @描述 随机 set key
     * @作者 lixing
     * @日期 2021/7/4 15:15
     * @Param [key, value]
     */
    @Override
    public boolean removeSet(String key, E value) {
        RSet<E> rSet = redissonSingleClient.getSet(key);
        return rSet.remove(value);
    }

    /**
     * @描述 并集 set key
     * @作者 lixing
     * @日期 2021/7/4 15:19
     * @Param [key1 被并对象1, key2 被并对象2, newKey 如果不为空，则合并和的结果存入该key]
     * @return java.util.Set<E>
     */
    @Override
    public Set<E> getSetUnion(String key1, String key2, String newKey) {
        if (StrUtil.isEffective(newKey)) {
            RSet<E> newKeyObj = redissonSingleClient.getSet(newKey);
            newKeyObj.union(key1, key2);
            return newKeyObj.readAll();
        } else {
            RSet<E> key1Obj = redissonSingleClient.getSet(key1);
            return key1Obj.readUnion(key2);
        }
    }

    /**
     * @描述 交集 set key
     * @作者 lixing
     * @日期 2021/7/4 15:19
     * @Param [key1 被交对象1, key2 被交对象1, newKey 如果不为空，则合并和的结果存入该key]
     * @return java.util.Set<E>
     */
    @Override
    public Set<E> getSetIntersect(String key1, String key2, String newKey) {
        if (StrUtil.isEffective(newKey)) {
            RSet<E> newKeyObj = redissonSingleClient.getSet(newKey);
            newKeyObj.intersection(key1, key2);
            return newKeyObj.readAll();
        } else {
            RSet<E> key1Obj = redissonSingleClient.getSet(key1);
            return key1Obj.readIntersection(key2);
        }
    }

    /**
     * @描述 差集 set key
     * @作者 lixing
     * @日期 2021/7/4 15:19
     * @Param [key1 被差对象1, key2 被差对象1, newKey 如果不为空，则合并和的结果存入该key]
     * @return java.util.Set<E>
     */
    @Override
    public Set<E> getSetDifference(String key1, String key2, String newKey) {
        if (StrUtil.isEffective(newKey)) {
            RSet<E> newKeyObj = redissonSingleClient.getSet(newKey);
            newKeyObj.diff(key1, key2);
            return newKeyObj.readAll();
        } else {
            RSet<E> key1Obj = redissonSingleClient.getSet(key1);
            return key1Obj.readDiff(key2);
        }
    }

    // TODO ================================================================================================ ZSET 有序集合
    /**
     * @描述 添加 zset key
     * @作者 lixing
     * @日期 2021/7/4 15:30
     * @Param [key, score, value]
     */
    @Override
    public void setZset(String key, double score, E value) {
        RScoredSortedSet<E> rzSet = redissonSingleClient.getScoredSortedSet(key);
        rzSet.add(score, value);
    }

    /**
     * @描述 修改 zset score
     * @作者 lixing
     * @日期 2021/7/4 15:34
     * @Param [key, value, score]
     */
    @Override
    public void setZsetScore(String key, E value, double score) {
        RScoredSortedSet<E> rzSet = redissonSingleClient.getScoredSortedSet(key);
        rzSet.addScore(value, score);
    }

    /**
     * @描述 随机 set key
     * @作者 lixing
     * @日期 2021/7/4 15:15
     * @Param [key, number 随机数量]
     * @return java.util.Collection<E>
     */
    @Override
    public Collection<E> getZsetByRandom(String key, int number) {
        RScoredSortedSet<E> rzSet = redissonSingleClient.getScoredSortedSet(key);
        return rzSet.random(number);
    }

    /**
     * @描述 获取指定score范围内的key数量
     * @作者 lixing
     * @日期 2021/7/4 15:36
     * @Param [key, minxScore 最小得分, minxFlag 是否包含最小得分, maxScore 最高得分, maxFlag 是否包含最大得分]
     */
    @Override
    public long getZsetCount(String key, double minxScore, boolean minxFlag, double maxScore, boolean maxFlag) {
        RScoredSortedSet<E> rzSet = redissonSingleClient.getScoredSortedSet(key);
        return rzSet.count(minxScore, minxFlag, maxScore, maxFlag);
    }

    /**
     * @描述 查询 set key 的位置
     * @作者 lixing
     * @日期 2021/7/4 15:15
     * @Param [key, value]
     */
    @Override
    public int rankZset(String key, E value) {
        RScoredSortedSet<E> rScoredSortedSet = redissonSingleClient.getScoredSortedSet(key);
        return rScoredSortedSet.rank(value);
    }

    /**
     * @描述 查询 set key 的得分
     * @作者 lixing
     * @日期 2021/7/4 15:15
     * @Param [key, value]
     */
    @Override
    public double scoreZset(String key, E value) {
        RScoredSortedSet<E> rScoredSortedSet = redissonSingleClient.getScoredSortedSet(key);
        return rScoredSortedSet.getScore(value);
    }

    /**
     * @描述 删除 zset key
     * @作者 lixing
     * @日期 2021/7/4 15:15
     * @Param [key, value]
     */
    @Override
    public boolean removeZset(String key, E value) {
        RScoredSortedSet<E> rzSet = redissonSingleClient.getScoredSortedSet(key);
        return rzSet.remove(value);
    }

    /**
     * @描述 查询（升序） zset score
     * @作者 lixing
     * @日期 2021/7/4 15:41
     * @Param [key]
     * @return java.util.Collection<E>
     */
    @Override
    public Collection<E> getZsetByRange(String key) {
        RScoredSortedSet<E> rzSet = redissonSingleClient.getScoredSortedSet(key);
        int size = rzSet.size();
        return rzSet.valueRange(0, size);
    }

    /**
     * @描述 查询（降序） zset score
     * @作者 lixing
     * @日期 2021/7/4 15:41
     * @Param [key]
     * @return java.util.Collection<E>
     */
    @Override
    public Collection<E> getZsetByRangeReversed(String key) {
        RScoredSortedSet<E> rzSet = redissonSingleClient.getScoredSortedSet(key);
        int size = rzSet.size();
        return rzSet.valueRangeReversed(0, size);
    }

    /**
     * @描述 并集 zset key
     * @作者 lixing
     * @日期 2021/7/4 15:19
     * @Param [key1 被并对象1, key2 被并对象1, newKey 如果不为空，则合并和的结果存入该key]
     * @return @return java.util.Collection<E>
     */
    @Override
    public Collection<E> getZsetUnion(String key1, String key2, String newKey) {
        if (StrUtil.isEffective(newKey)) {
            RScoredSortedSet<E> newKeyObj = redissonSingleClient.getScoredSortedSet(newKey);
            newKeyObj.union(key1, key2);
            return newKeyObj.readAll();
        } else {
            RScoredSortedSet<E> key1Obj = redissonSingleClient.getScoredSortedSet(key1);
            return key1Obj.readUnion(key2);
        }
    }

    /**
     * @描述 交集 zset key
     * @作者 lixing
     * @日期 2021/7/4 15:19
     * @Param [key1 被交对象1, key2 被交对象1, newKey 如果不为空，则合并和的结果存入该key]
     * @return java.util.Collection<E>
     */
    @Override
    public Collection<E> getZsetIntersect(String key1, String key2, String newKey) {
        if (StrUtil.isEffective(newKey)) {
            RScoredSortedSet<E> newKeyObj = redissonSingleClient.getScoredSortedSet(newKey);
            newKeyObj.intersection(key1, key2);
            return newKeyObj.readAll();
        } else {
            RScoredSortedSet<E> key1Obj = redissonSingleClient.getScoredSortedSet(key1);
            return key1Obj.readIntersection(key2);
        }
    }

    /**
     * @描述 差集 zset key
     * @作者 lixing
     * @日期 2021/7/4 15:19
     * @Param [key1 被差对象1, key2 被差对象1, newKey 如果不为空，则合并和的结果存入该key]
     * @return java.util.Collection<E>
     */
    @Override
    public Collection<E> getZsetDifference(String key1, String key2, String newKey) {
        if (StrUtil.isEffective(newKey)) {
            RScoredSortedSet<E> newKeyObj = redissonSingleClient.getScoredSortedSet(newKey);
            newKeyObj.diff(key1, key2);
            return newKeyObj.readAll();
        } else {
            RScoredSortedSet<E> key1Obj = redissonSingleClient.getScoredSortedSet(key1);
            return key1Obj.readDiff(key2);
        }
    }

    // TODO ================================================================================================= 地理空间对象
    /**
     * @描述 添加 geo key
     * @作者 lixing
     * @日期 2021/7/4 15:57
     * @Param [key, geoEntry]
     */
    @Override
    public void setGeo(String key, GeoEntry geoEntry) {
        RGeo<String> rGeo = redissonSingleClient.getGeo(key);
        //rGeo.add(new GeoEntry(13.361389, 38.115556, "Palermo"));
        rGeo.add(geoEntry);
    }

    /**
     * @描述 查询 geo 成员
     * @作者 lixing
     * @日期 2021/7/4 15:59
     * @Param [key, memberName]
     * @return java.util.Map<java.lang.String, org.redisson.api.GeoPosition>
     */
    @Override
    public Map<String, GeoPosition> getGeoMember(String key, String memberName) {
        RGeo<String> rGeo = redissonSingleClient.getGeo(key);
        Map<String, GeoPosition> geoPositionMap = rGeo.pos(memberName);
        return geoPositionMap;
    }

    /**
     * @描述 查询 geo 成员之间的执行距离
     * @作者 lixing
     * @日期 2021/7/4 16:00
     * @Param [key, memberName1, memberName2]
     * @return double
     */
    @Override
    public double getGeoDistance(String key, String memberName1, String memberName2) {
        RGeo<String> rGeo = redissonSingleClient.getGeo(key);
        Double distance = rGeo.dist(memberName1, memberName2, GeoUnit.METERS);
        return distance;
    }

}
